package com.gxc.array;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

/**
 * 请实现一个简易内存池,根据请求命令完成内存分配和释放。
 * 内存池支持两种操作命令，REQUEST和RELEASE，其格式为：
 * REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。
 * RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
 * 注意：
 *
 * 内存池总大小为100字节。
 * 内存池地址分配必须是连续内存，并优先从低地址分配。
 * 内存释放后可被再次分配，已释放的内存在空闲时不能被二次释放。
 * 不会释放已申请的内存块的中间地址。
 * 释放操作只是针对首地址所对应的单个内存块进行操作，不会影响其它内存块。
 * 输入描述
 * 首行为整数 N , 表示操作命令的个数，取值范围：0 < N <= 100。
 *
 * 接下来的N行, 每行将给出一个操作命令，操作命令和参数之间用 “=”分割。
 *
 * 输出描述
 * 请求分配指定大小内存时，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error
 *
 * 释放掉之前分配的内存时，释放成功无需输出，如果释放不存在的首地址则输出error。
 */
public class MemoryPool {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());

        List<String> inputList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            inputList.add(scanner.nextLine());
        }
        scanner.close();

        LinkedList<Integer[]> used = new LinkedList<>();
        used.add(new Integer[]{101, 101});
        for (int i = 0; i < inputList.size(); i++) {
            String[] split = inputList.get(i).split("=");
            String key = split[0];
            int value = Integer.parseInt(split[1]);

            if ("REQUEST".equals(key)) {
                int start = 0;
                //是否申请到内存标识
                boolean flag = true;

                for (int j = 0; j < used.size(); j++) {
                    Integer[] ues = used.get(j);

                    int end = start + value - 1;
                    Integer[] range = {start, end};
                    if (hasIntersection(ues, range)) {
                        start = ues[1] + 1;
                    } else {
                        used.add(j, range);
                        flag = false;
                        System.out.println(start);
                        break;
                    }
                }
                if (flag) System.out.println("error");
            } else {
                boolean flag = true;
                for (int j = 0; j < used.size(); j++) {
                    Integer[] ues = used.get(j);
                    if (ues[0] == value) {
                        flag = false;
                        used.remove(j);
                        break;
                    }
                }
                if (flag) System.out.println("error");
            }
        }
    }

    // 判断两个区间是否存在交集
    public static boolean hasIntersection(Integer[] range1, Integer[] range2) {
        int s1 = range1[0];
        int e1 = range1[1];

        int s2 = range2[0];
        int e2 = range2[1];

        if (s1 == s2) return true;
        else if (s1 < s2) return e1 >= s2;
        else return e2 >= s1;
    }
}
